Codecov Report

Merging #329 (81c5dc2) into main (296cd5e) will decrease coverage by 3.67%.
Report is 4 commits behind head on main.
The diff coverage is 59.65%.

@@            Coverage Diff             @@
##             main     #329      +/-   ##
==========================================
- Coverage   96.54%   92.88%   -3.67%     
==========================================
  Files          14       17       +3     
  Lines        4140     4608     +468     
==========================================
+ Hits         3997     4280     +283     
- Misses        143      328     +185     

... and 1 file with indirect coverage changes

@maleadt I've implemented a prototype of @ccall macro expansion here, based on porting the implementation of @ccall from Julia 1.9. It turns out to be an excellent test case because it:

• Has interesting error reporting cases
• Constructs expressions for which there's no surface syntax (Expr(:foreigncall))
• Pattern matching on the input
• However is not overly complex in the scheme of things

Quick benchmarks suggest ~7x speed improvement over Base's current macro expansion compared with the @ccall implementation from Julia 1.9 (implementation I coped into the module CCall19 for this test. ie, before JuliaLang/julia#50077)

julia> ex = parsestmt(SyntaxNode, "CCall.@ccall libfoo.bar(a::A, b::B, c::C, d::D, e::E)::X")
       @benchmark JuliaSyntax.macroexpand(Main, ex)
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  35.980 μs …  33.100 ms  ┊ GC (min … max): 0.00% … 99.77%
 Time  (median):     38.453 μs               ┊ GC (median):    0.00%
 Time  (mean ± σ):   43.957 μs ± 330.734 μs  ┊ GC (mean ± σ):  7.51% ±  1.00%

  ▅▇██▄▄▂                                                      ▂
  ████████▇▆▅▄▄▂▄▄▆▆▆█▇▇▆▇▇▇▇▇▆▆▆▅▆▆▆▇▆▄▄▆▆▆▇▆▅▅▆▅▅▅▂▄▄▅▇▆▄▄▄▄ █
  36 μs         Histogram: log(frequency) by time      88.2 μs <

 Memory estimate: 48.84 KiB, allocs estimate: 1163.

julia> ex = :(CCall19.@ccall libfoo.bar(a::A, b::B, c::C, d::D, e::E)::X)
       @benchmark macroexpand(Main, ex)
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  217.853 μs …  10.244 ms  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     227.139 μs               ┊ GC (median):    0.00%
 Time  (mean ± σ):   293.611 μs ± 602.926 μs  ┊ GC (mean ± σ):  0.00% ± 0.00%

  █▇▄▃▄▂▂▂▂▁▁▁                                                  ▂
  ████████████▇██▇▇▇▇▆▅▇▆▅▆▅▅▆▅▄▁▄▄▁▁▃▃▄▃▄▃▁▃▄▁▁▃▁▁▁▁▁▁▁▁▁▄▄▃▃▅ █
  218 μs        Histogram: log(frequency) by time        798 μs <

 Memory estimate: 18.57 KiB, allocs estimate: 365.

It's hard to get a perfectly fair comparison here but these kind of speedups are generally what I've observed in JuliaSyntax's parser vs the flisp as well.

It looks like that benchmark above is measuring hygenic-scope resolution rather than macro expansion and this is the real cost. Hacking libjulia to add a function which doesn't call jl-expand-macroscope shows that macro expansion itself is really not a problem. As might be expected given that expansion itself is written in C and just calls Julia code:

julia> ex = :(CCall19.@ccall libfoo.bar(a::A, b::B, c::C, d::D, e::E)::X)
       @benchmark macroexpand_no_scope(Main, ex)
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  12.125 μs … 73.399 μs  ┊ GC (min … max): 0.00% … 0.00%
 Time  (median):     13.049 μs              ┊ GC (median):    0.00%
 Time  (mean ± σ):   13.501 μs ±  2.584 μs  ┊ GC (mean ± σ):  0.00% ± 0.00%

   ▃█▅▁                                                        
  ▃█████▆▄▃▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▂▁▂▁▁▂▂▂▁▁▁▁▂▁▂▁▂▂▂▂▂▂▂▂▂▂▁▂ ▃
  12.1 μs         Histogram: frequency by time        28.4 μs <

 Memory estimate: 14.98 KiB, allocs estimate: 295.

This also means it's very hard to do a fair benchmark of this in the new prototype without also reimplementing the parts of lowering which do scope resolution. (Which I want to do! It's just a fair bit of work.)

This also means it's very hard to do a fair benchmark of this in the new prototype without also reimplementing the parts of lowering which do scope resolution.

I see; thanks for clarifying! I had trouble myself too figuring out where the real cost of the @ccall expansion was, and happy to see this considered for future work. And for the time being, I can just go back to plain ccall anyway.

This work is continuing over at https://github.com/c42f/JuliaLowering.jl so I'll close this.

Over there I've got enough things working that we can produce a CodeInfo directly for some simple cases without ever calling into Julia's existing lowering implementation. Also an entirely new and much more flexible data structure to replace SyntaxNode. Automatic hygiene also works, including weird cases like macros recursively expanding to calls to themselves, and the old scope resolution mechanism is entirely deleted and replaced with something better. There's lots and lots to do though - many very basic things like branching don't even work yet (ie, come back in half a year ;-) )

It looks like that benchmark above is measuring hygenic-scope resolution rather than macro expansion and this is the real cost.

At some point I'll port the @ccall implementation from this PR over to there and we'll finally be able to understand the performance implications. But the new implementation basically deletes the separate hygenic-scope resolution pass entirely so I expect good things 😊